{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook has been prepared based on the homework given in [berkeleydeeprl course](https://github.com/berkeleydeeprlcourse/homework/blob/0015ad14cf155d59fede725f2d783f4683cc8215/sp17_hw/hw2/HW2.ipynb) and https://github.com/dennybritz/reinforcement-learning.\n",
    "This reviews the two classic methods for solving Markov Decision Processes (MDPs) with finite state and action spaces. We have value iteration (VI) and policy iteration (PI) for a finite MDP, both of which find the optimal policy in a finite number of iterations.\n",
    "\n",
    "The experiments here use the [Frozen Lake environment](https://gym.openai.com/envs/FrozenLake-v0), a simple gridworld MDP that is taken from gym. In this MDP, the agent must navigate from the start state to the goal state on a 4x4 grid, with stochastic transitions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# © Ozan Arkan Can, 2018.\n",
    "using Pkg; for p in (\"Gym\",\"Plots\"); haskey(Pkg.installed(),p) || Pkg.add(p); end\n",
    "ENV[\"GYM_ENVS\"]=\"atari:classic_control:box2d\"\n",
    "using Gym, Random, Printf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "env = GymEnv(\"FrozenLake-v0\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    Winter is here. You and your friends were tossing around a frisbee at the park\n",
      "    when you made a wild throw that left the frisbee out in the middle of the lake.\n",
      "    The water is mostly frozen, but there are a few holes where the ice has melted.\n",
      "    If you step into one of those holes, you'll fall into the freezing water.\n",
      "    At this time, there's an international frisbee shortage, so it's absolutely imperative that\n",
      "    you navigate across the lake and retrieve the disc.\n",
      "    However, the ice is slippery, so you won't always move in the direction you intend.\n",
      "    The surface is described using a grid like the following\n",
      "\n",
      "        SFFF\n",
      "        FHFH\n",
      "        FFFH\n",
      "        HFFG\n",
      "\n",
      "    S : starting point, safe\n",
      "    F : frozen surface, safe\n",
      "    H : hole, fall to your doom\n",
      "    G : goal, where the frisbee is located\n",
      "\n",
      "    The episode ends when you reach the goal or fall in a hole.\n",
      "    You receive a reward of 1 if you reach the goal, and zero otherwise.\n",
      "\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "println(env.gymenv[:unwrapped][:__doc__])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\u001b[41mS\u001b[0mFFF\n",
      "FHFH\n",
      "FFFH\n",
      "HFFG\n",
      "\n",
      "  (Right)\n",
      "S\u001b[41mF\u001b[0mFF\n",
      "FHFH\n",
      "FFFH\n",
      "HFFG\n",
      "\n",
      "  (Right)\n",
      "SFFF\n",
      "F\u001b[41mH\u001b[0mFH\n",
      "FFFH\n",
      "HFFG\n",
      "\n"
     ]
    }
   ],
   "source": [
    "Random.seed!(1); seed!(env, 1);\n",
    "irender(env)=println(render(env; mode=\"ansi\")[:getvalue]())\n",
    "reset!(env)\n",
    "irender(env)\n",
    "for t=1:100\n",
    "    a = sample(env.action_space)\n",
    "    ob, rew, done, _ = step!(env, a)\n",
    "    irender(env)\n",
    "    if done\n",
    "        break\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the episode above, the agent falls into a hole after two time steps. Also note the stochasticity on the second step, the Right action is selected, but the agent moves down.\n",
    "\n",
    "We extract the relevant information from the gym env into the MDP struct below. The env object won't be used any further, we'll just use the mdp object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mdp.P is a two-level dict where the first key is the state and the second key is the action.\n",
      "The 2D grid cells are associated with indices [1, 2, ..., 16] from left to right and top to down, as in\n",
      "[1 2 3 4\n",
      " 5 6 7 8\n",
      " 9 10 11 12\n",
      " 13 14 15 16]\n",
      "mdp.P[state][action] is a list of tuples (probability, nextstate, reward).\n",
      "\n",
      "For example, state 1 is the initial state, and the transition information for s=1, a=1 is \n",
      "P[1][1] =Any[(0.1, 1, 0.0), (0.8, 1, 0.0), (0.1, 5, 0.0)]\n",
      "\n",
      "As another example, state 6 corresponds to a hole in the ice, which transitions to itself with probability 1 and reward 0.\n",
      "P[6][1] =Any[(1.0, 6, 0)]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "mutable struct MDP\n",
    "    P # state transition and reward probabilities, explained below\n",
    "    nS # number of states\n",
    "    nA # number of actions\n",
    "    desc # 2D array specifying what each grid cell means (used for plotting)\n",
    "end\n",
    "\n",
    "#We will modify the original transition matrix whicch allows more stable policies.\n",
    "#https://github.com/berkeleydeeprlcourse/homework/blob/60b3ef08c2dca3961efb63b32683bb588571f226/sp17_hw/hw2/frozen_lake.py#L89\n",
    "\n",
    "function inc(row, col, a)\n",
    "    if a==0 # left\n",
    "        col = max(col-1,0)\n",
    "    elseif a==1 # down\n",
    "        row = min(row+1,3)\n",
    "    elseif a==2 # right\n",
    "        col = min(col+1,3)\n",
    "    else # up\n",
    "        row = max(row-1,0)\n",
    "    end\n",
    "    return (row, col)\n",
    "end\n",
    "\n",
    "P = Dict(s => Dict(a => [] for a=1:4) for s=1:16)\n",
    "desc = map(x->convert(Array, x), env.gymenv[:unwrapped][:desc])\n",
    "for row=0:3\n",
    "    for col=0:3\n",
    "        s = row * 4 + col + 1\n",
    "        for a=1:4\n",
    "            li = P[s][a]\n",
    "            letter = desc[row+1][col+1]\n",
    "            if occursin(letter, \"GH\")\n",
    "                push!(li, (1.0, s, 0))\n",
    "            else            \n",
    "                for b in [(a+2)%4+1, a, a%4+1]\n",
    "                    newrow, newcol = inc(row, col, b-1)\n",
    "                    newstate = newrow * 4 + newcol + 1\n",
    "                    newletter = desc[newrow+1][newcol+1]\n",
    "                    reward = float(newletter == \"G\")\n",
    "                    push!(li, (b==a ? 0.8 : 0.1, newstate, reward))\n",
    "                end\n",
    "            end\n",
    "        end\n",
    "    end\n",
    "end\n",
    "\n",
    "mdp = MDP(P, env.gymenv[:unwrapped][:nS], env.gymenv[:unwrapped][:nA],desc);\n",
    "println(\"mdp.P is a two-level dict where the first key is the state and the second key is the action.\")\n",
    "println(\"The 2D grid cells are associated with indices [1, 2, ..., 16] from left to right and top to down, as in\")\n",
    "println(\"[1 2 3 4\\n 5 6 7 8\\n 9 10 11 12\\n 13 14 15 16]\")\n",
    "println(\"mdp.P[state][action] is a list of tuples (probability, nextstate, reward).\\n\")\n",
    "println(\"For example, state 1 is the initial state, and the transition information for s=1, a=1 is \\nP[1][1] =\", mdp.P[1][1], \"\\n\")\n",
    "println(\"As another example, state 6 corresponds to a hole in the ice, which transitions to itself with probability 1 and reward 0.\")\n",
    "println(\"P[6][1] =\", mdp.P[6][1], '\\n')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Value Iteration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we have the value iteration, which has the following pseudocode:\n",
    "\n",
    "---\n",
    "Initialize $V^{(0)}(s)=0$, for all $s$\n",
    "\n",
    "For $i=0, 1, 2, \\dots$\n",
    "- $V^{(i+1)}(s) = \\max_a \\sum_{s'} P(s,a,s') [ R(s,a,s') + \\gamma V^{(i)}(s')]$, for all $s$\n",
    "\n",
    "---\n",
    "\n",
    "We additionally define the sequence of greedy policies $\\pi^{(0)}, \\pi^{(1)}, \\dots, \\pi^{(n-1)}$, where\n",
    "$$\\pi^{(i)}(s) = \\arg \\max_a \\sum_{s'} P(s,a,s') [ R(s,a,s') + \\gamma V^{(i)}(s')]$$\n",
    "\n",
    "The code returns two lists: $[V^{(0)}, V^{(1)}, \\dots, V^{(n)}]$ and $[\\pi^{(0)}, \\pi^{(1)}, \\dots, \\pi^{(n-1)}]$\n",
    "\n",
    "We choose the lower-index action to break ties in $\\arg \\max_a$. This is done automatically by findmax. This will only affect the \"# chg actions\" printout below--it won't affect the values computed.\n",
    "\n",
    "<div class=\"alert alert-warning\">\n",
    "Warning: We make a copy of your value function each iteration and use that copy for the update--instead of updating the value function in place. \n",
    "Updating in-place is also a valid algorithm, sometimes called Gauss-Seidel value iteration or asynchronous value iteration, but it will cause you to get different results than presented here.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration | max|V-Vprev| | # chg actions | V[1]\n",
      "----------+--------------+---------------+---------\n",
      "   1      | 0.80000      |  N/A          | 0.000\n",
      "   2      | 0.60800      |    2          | 0.000\n",
      "   3      | 0.51984      |    2          | 0.000\n",
      "   4      | 0.39508      |    2          | 0.000\n",
      "   5      | 0.30026      |    1          | 0.000\n",
      "   6      | 0.25355      |    0          | 0.254\n",
      "   7      | 0.10478      |    0          | 0.345\n",
      "   8      | 0.09657      |    0          | 0.442\n",
      "   9      | 0.03656      |    0          | 0.478\n",
      "  10      | 0.02772      |    0          | 0.506\n",
      "  11      | 0.01111      |    0          | 0.517\n",
      "  12      | 0.00735      |    0          | 0.524\n",
      "  13      | 0.00310      |    0          | 0.527\n",
      "  14      | 0.00190      |    0          | 0.529\n",
      "  15      | 0.00083      |    0          | 0.530\n",
      "  16      | 0.00049      |    0          | 0.531\n",
      "  17      | 0.00022      |    0          | 0.531\n",
      "  18      | 0.00013      |    0          | 0.531\n",
      "  19      | 0.00006      |    0          | 0.531\n",
      "  20      | 0.00003      |    0          | 0.531\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Inputs:\n",
    "        mdp: MDP\n",
    "        gamma: discount factor\n",
    "        nIt: number of iterations, corresponding to n above\n",
    "    Outputs:\n",
    "        (value_functions, policies)\n",
    "\"\"\"\n",
    "function value_iteration(mdp, gamma, nIt)\n",
    "    \"\"\"\n",
    "        Helper function to calculate the value for all action in a given state.\n",
    "        \n",
    "        Args:\n",
    "            state: The state to consider (int)\n",
    "            V: The value to use as an estimator, Vector of length mdp.nS\n",
    "        \n",
    "        Returns:\n",
    "            A vector of length mdp.nA containing the expected value of each action.\n",
    "    \"\"\"\n",
    "    function one_step_lookahead(state, V)\n",
    "        A = zeros(mdp.nA)\n",
    "        for a=1:mdp.nA\n",
    "            for (prob, next_state, reward) in mdp.P[state][a]\n",
    "                A[a] += prob * (reward + γ * V[next_state])\n",
    "            end\n",
    "        end\n",
    "        return A\n",
    "    end\n",
    "    \n",
    "    println(\"Iteration | max|V-Vprev| | # chg actions | V[1]\")\n",
    "    println(\"----------+--------------+---------------+---------\")\n",
    "    \n",
    "    Vs = [zeros(mdp.nS)] # list of value functions contains the initial value function V^{(0)}, which is zero\n",
    "    πs = []\n",
    "    for it=1:nIt\n",
    "        old_π = length(πs) > 0 ? πs[end] : nothing # \\pi^{(it)} = Greedy[V^{(it-1)}]. Just used for printout\n",
    "        Vprev = Vs[end] # V^{(it)}\n",
    "        # V: bellman backup on Vprev\n",
    "        #     corresponding to the math above: V^{(it+1)} = T[V^{(it)}]\n",
    "        #     array of floats\n",
    "        V = zeros(mdp.nS)\n",
    "        for s=1:mdp.nS\n",
    "            # Do a one-step lookahead to find the best action\n",
    "            A = one_step_lookahead(s, Vprev)\n",
    "            best_action_value = maximum(A)\n",
    "            # Update the value function\n",
    "            V[s] = best_action_value \n",
    "        end\n",
    "        \n",
    "        # π: greedy policy for Vprev, \n",
    "        #     corresponding to the math above: \\pi^{(it)} = Greedy[V^{(it)}]\n",
    "        #     array of ints\n",
    "        π = zeros(Int, mdp.nS)\n",
    "        for s=1:mdp.nS\n",
    "            # One step lookahead to find the best action for this state\n",
    "            A = one_step_lookahead(s, V)\n",
    "            #there might me more than one action with max value\n",
    "            #chose the first one\n",
    "            best_action = findmax(A)[2]\n",
    "            # Always take the best action\n",
    "            π[s] = best_action\n",
    "        end\n",
    "        \n",
    "        max_diff = maximum(abs.(V - Vprev))\n",
    "        nChgActions= old_π == nothing ? \"N/A\" : sum((π .!= old_π))\n",
    "        println(@sprintf(\"%4i      | %6.5f      | %4s          | %5.3f\", it, max_diff, nChgActions, V[1]))\n",
    "        push!(Vs, V)\n",
    "        push!(πs, π)\n",
    "    end\n",
    "    return Vs, πs\n",
    "end\n",
    "\n",
    "γ=0.95 # we'll be using this same value in subsequent implementations\n",
    "Vs_VI, πs_VI = value_iteration(mdp, γ, 20);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reshaped Grid Policy (1=left, 2=down, 3=right, 4=up)\n",
      "(reshape(πs_VI[end], 4, 4))' = [2 3 2 1; 2 1 2 1; 3 2 2 1; 1 3 3 1]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4×4 LinearAlgebra.Adjoint{Int64,Array{Int64,2}}:\n",
       " 2  3  2  1\n",
       " 2  1  2  1\n",
       " 3  2  2  1\n",
       " 1  3  3  1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "println(\"Reshaped Grid Policy (1=left, 2=down, 3=right, 4=up)\")\n",
    "@show reshape(πs_VI[end], 4, 4)'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reshaped Grid Value Function\n",
      "(reshape(Vs_VI[20], 4, 4))' = [0.531121 0.470613 0.560417 0.470613; 0.573669 0.0 0.619748 0.0; 0.683138 0.827169 0.81546 0.0; 0.0 0.90106 0.969578 0.0]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4×4 LinearAlgebra.Adjoint{Float64,Array{Float64,2}}:\n",
       " 0.531121  0.470613  0.560417  0.470613\n",
       " 0.573669  0.0       0.619748  0.0     \n",
       " 0.683138  0.827169  0.81546   0.0     \n",
       " 0.0       0.90106   0.969578  0.0     "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "println(\"Reshaped Grid Value Function\")\n",
    "@show reshape(Vs_VI[20], 4, 4)'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Policy Iteration\n",
    "\n",
    "Next we will implement the policy iteration (PI), which has the following pseudocode:\n",
    "\n",
    "---\n",
    "Initialize $\\pi_0$\n",
    "\n",
    "For $n=0, 1, 2, \\dots$\n",
    "- Compute the state-value function $V^{\\pi_{n}}$\n",
    "- Compute new policy $\\pi_{n+1}(s) = \\operatorname*{argmax}_a V^{\\pi_{n}}(s,a)$\n",
    "---\n",
    "\n",
    "### Policy Evaluation\n",
    "\n",
    "Here, we implement a function called `policy_eval` that computes the state-value function $V^{\\pi}$ for an arbitrary policy $\\pi$.\n",
    "Recall that $V^{\\pi}$ satisfies the following linear equation:\n",
    "$$V^{\\pi}(s) = \\sum_{s'} P(s,\\pi(s),s')[ R(s,\\pi(s),s') + \\gamma V^{\\pi}(s')]$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "policy_eval"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Evaluate a policy given an environment and a full description of the environment's dynamics.\n",
    "    \n",
    "    Args:\n",
    "        π: [S] shaped vector representing the policy.\n",
    "        mdp: mdp.P represents the transition probabilities of the environment.\n",
    "            mdp.P[s][a] is a list of transition tuples (prob, next_state, reward).\n",
    "            mpd.nS is a number of states in the environment. \n",
    "            mdp.nA is a number of actions in the environment.\n",
    "        γ: discount factor.\n",
    "        θ: We stop evaluation once our value function change is less than theta for all states.\n",
    "    \n",
    "    Returns:\n",
    "        Vector of length mdp.nS representing the value function.\n",
    "\"\"\"\n",
    "function policy_eval(π, mdp, γ=0.95, θ=1e-4)\n",
    "    # Start with a random (all 0) value function\n",
    "    V = zeros(mdp.nS)\n",
    "    while true\n",
    "        Δ = 0\n",
    "        # For each state, perform a \"full backup\"\n",
    "        for s=1:mdp.nS\n",
    "            v = 0\n",
    "            # Look at the possible next actions\n",
    "            for a in π[s]\n",
    "                action_prob = 1.0#Deterministic policy\n",
    "                # For each action, look at the possible next states...\n",
    "                for  (prob, next_state, reward) in mdp.P[s][a]\n",
    "                    # Calculate the expected value\n",
    "                    v += action_prob * prob * (reward + γ * V[next_state])\n",
    "                end\n",
    "            end\n",
    "            # How much our value function changed (across any states)\n",
    "            Δ = max(Δ, abs(v - V[s]))\n",
    "            V[s] = v\n",
    "        end\n",
    "        # Stop evaluating once our value function change is below a threshold\n",
    "        if Δ < θ\n",
    "            break\n",
    "        end\n",
    "    end\n",
    "    return V\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "γ = 0.95\n",
    "θ = 1e-5\n",
    "random_policy = rand(1:mdp.nA, mdp.nS)\n",
    "V = policy_eval(random_policy, mdp, γ, θ);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reshaped Grid Policy (Random) (1=left, 2=down, 3=right, 4=up)\n",
      "(reshape(random_policy, 4, 4))' = [4 2 2 3; 3 4 3 4; 1 1 1 3; 1 2 3 4]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4×4 LinearAlgebra.Adjoint{Int64,Array{Int64,2}}:\n",
       " 4  2  2  3\n",
       " 3  4  3  4\n",
       " 1  1  1  3\n",
       " 1  2  3  4"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "println(\"Reshaped Grid Policy (Random) (1=left, 2=down, 3=right, 4=up)\")\n",
    "@show reshape(random_policy, 4, 4)'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reshaped Grid Value Function\n",
      "(reshape(V, 4, 4))' = [0.00057495 0.000889683 0.00879026 0.0; 5.67121e-5 0.0 0.011455 0.0; 2.21224e-5 0.0336961 0.11179 0.0; 0.0 0.354527 0.895713 0.0]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4×4 LinearAlgebra.Adjoint{Float64,Array{Float64,2}}:\n",
       " 0.00057495  0.000889683  0.00879026  0.0\n",
       " 5.67121e-5  0.0          0.011455    0.0\n",
       " 2.21224e-5  0.0336961    0.11179     0.0\n",
       " 0.0         0.354527     0.895713    0.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "println(\"Reshaped Grid Value Function\")\n",
    "@show reshape(V, 4, 4)'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "policy_iteration"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Policy Iteration Algorithm. Iteratively evaluates and improves a policy.\n",
    "    \n",
    "    Args:\n",
    "        mdp: A markov decision process.\n",
    "        γ: discount factor.\n",
    "        nIt: number of iteration\n",
    "        \n",
    "    Returns: (value_functions, policies)\n",
    "        \n",
    "\"\"\"\n",
    "function policy_iteration(mdp, γ, nIt)\n",
    "    \"\"\"\n",
    "        Helper function to calculate the value for all action in a given state.\n",
    "        \n",
    "        Args:\n",
    "            state: The state to consider (int)\n",
    "            V: The value to use as an estimator, Vector of length mdp.nS\n",
    "        \n",
    "        Returns:\n",
    "            A vector of length mdp.nA containing the expected value of each action.\n",
    "    \"\"\"\n",
    "    function one_step_lookahead(state, V)\n",
    "        A = zeros(mdp.nA)\n",
    "        for a=1:mdp.nA\n",
    "            for (prob, next_state, reward) in mdp.P[state][a]\n",
    "                A[a] += prob * (reward + γ * V[next_state])\n",
    "            end\n",
    "        end\n",
    "        return A\n",
    "    end\n",
    "    Vs = []\n",
    "    πs = []\n",
    "    π_prev = rand(1:mdp.nA, mdp.nS)#start with a randomly initialized policy\n",
    "    push!(πs, π_prev)\n",
    "    println(\"Iteration | # chg actions | V[1]\")\n",
    "    println(\"----------+---------------+---------\")\n",
    "    \n",
    "    for it=1:nIt\n",
    "        π_prev = πs[end]\n",
    "        Vπ = policy_eval(π_prev, mdp, γ)\n",
    "        π = zeros(Int, mdp.nS)\n",
    "        for s=1:mdp.nS\n",
    "            # One step lookahead to find the best action for this state\n",
    "            A = one_step_lookahead(s, Vπ)\n",
    "            #there might me more than one action with max value\n",
    "            #chose the first one\n",
    "            best_action = findmax(A)[2]\n",
    "            # Always take the best action\n",
    "            π[s] = best_action\n",
    "        end\n",
    "        nChgActions= sum((π .!= π_prev))\n",
    "        println(@sprintf(\"%4i      | %6i        | %6.5f\", it, nChgActions, Vπ[1]))\n",
    "        push!(Vs, Vπ)\n",
    "        push!(πs, π)\n",
    "    end\n",
    "    return Vs, πs\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration | # chg actions | V[1]\n",
      "----------+---------------+---------\n",
      "   1      |     16        | 0.00000\n",
      "   2      |      1        | 0.45543\n",
      "   3      |      0        | 0.53115\n",
      "   4      |      0        | 0.53115\n",
      "   5      |      0        | 0.53115\n",
      "   6      |      0        | 0.53115\n",
      "   7      |      0        | 0.53115\n",
      "   8      |      0        | 0.53115\n",
      "   9      |      0        | 0.53115\n",
      "  10      |      0        | 0.53115\n",
      "  11      |      0        | 0.53115\n",
      "  12      |      0        | 0.53115\n",
      "  13      |      0        | 0.53115\n",
      "  14      |      0        | 0.53115\n",
      "  15      |      0        | 0.53115\n",
      "  16      |      0        | 0.53115\n",
      "  17      |      0        | 0.53115\n",
      "  18      |      0        | 0.53115\n",
      "  19      |      0        | 0.53115\n",
      "  20      |      0        | 0.53115\n"
     ]
    }
   ],
   "source": [
    "γ = 0.95\n",
    "Vs_PI, πs_PI = policy_iteration(mdp, γ, 20);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reshaped Grid Policy (1=left, 2=down, 3=right, 4=up)\n",
      "(reshape(πs_PI[end], 4, 4))' = [2 3 2 1; 2 1 2 1; 3 2 2 1; 1 3 3 1]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4×4 LinearAlgebra.Adjoint{Int64,Array{Int64,2}}:\n",
       " 2  3  2  1\n",
       " 2  1  2  1\n",
       " 3  2  2  1\n",
       " 1  3  3  1"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "println(\"Reshaped Grid Policy (1=left, 2=down, 3=right, 4=up)\")\n",
    "@show reshape(πs_PI[end], 4, 4)'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reshaped Grid Value Function\n",
      "(reshape(Vs_PI[end], 4, 4))' = [0.531154 0.470633 0.56043 0.470637; 0.573692 0.0 0.619751 0.0; 0.683153 0.827176 0.815462 0.0; 0.0 0.901063 0.969579 0.0]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4×4 LinearAlgebra.Adjoint{Float64,Array{Float64,2}}:\n",
       " 0.531154  0.470633  0.56043   0.470637\n",
       " 0.573692  0.0       0.619751  0.0     \n",
       " 0.683153  0.827176  0.815462  0.0     \n",
       " 0.0       0.901063  0.969579  0.0     "
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "println(\"Reshaped Grid Value Function\")\n",
    "@show reshape(Vs_PI[end], 4, 4)'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Plots; default(fmt=:png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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"
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels = reshape(map(x->\"V\"*string(x), 1:mdp.nS), 1, mdp.nS)\n",
    "plot(hcat(Vs_PI...)',label=labels, title=\"State Values for Policy Iteration\")\n",
    "xlabel!(\"Number of iterations\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can compare the convergence of value iteration and policy iteration on several states."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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"
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plots = []\n",
    "pallettes = [:blues, :reds, :greens, :blues, :reds]\n",
    "states = [1,9,11,14,15]\n",
    "for i=1:length(states)\n",
    "    s = states[i]\n",
    "    push!(plots, plot(hcat(hcat(Vs_VI[2:end]...)'[:, s], hcat(Vs_PI...)'[:, s]),\n",
    "            labels=[\"VI State $s\" \"PI State $s\"],\n",
    "            ylabel=\"V$s\", color_palette=pallettes[i], lw=4)\n",
    "    )\n",
    "end\n",
    "plot(plots...,layout=(5,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.0.0",
   "language": "julia",
   "name": "julia-1.0"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.0.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
